home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / Printing.p < prev    next >
Text File  |  1996-05-01  |  15KB  |  552 lines
  1. {
  2.      File:        Printing.p
  3.  
  4.      Contains:    Print Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Printing;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __PRINTING__}
  28. {$SETC __PRINTING__ := 1}
  29.  
  30. {$I+}
  31. {$SETC PrintingIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __ERRORS__}
  35. {$I Errors.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __DIALOGS__}
  38. {$I Dialogs.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __QUICKDRAW__}
  41. {$I Quickdraw.p}
  42. {$ENDC}
  43.  
  44. {$PUSH}
  45. {$ALIGN MAC68K}
  46. {$LibExport+}
  47.  
  48. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  49.  
  50. CONST
  51.     iPFMaxPgs                    = 128;
  52.     iPrPgFract                    = 120;                            { Page scale factor. ptPgSize (below) is in units of 1/iPrPgFract }
  53.     iPrPgFst                    = 1;                            { Page range constants }
  54.     iPrPgMax                    = 9999;
  55.     iPrRelease                    = 3;                            { Current version number of the code. }
  56.     iPrSavPFil                    = -1;
  57.     iPrAbort                    = $0080;
  58.     iPrDevCtl                    = 7;                            { The PrDevCtl Proc's ctl number }
  59.     lPrReset                    = $00010000;                    { The PrDevCtl Proc's CParam for reset }
  60.     lPrLineFeed                    = $00030000;
  61.     lPrLFStd                    = $0003FFFF;                    { The PrDevCtl Proc's CParam for std paper advance }
  62.     lPrLFSixth                    = $0003FFFF;
  63.     lPrPageEnd                    = $00020000;                    { The PrDevCtl Proc's CParam for end page }
  64.     lPrDocOpen                    = $00010000;
  65.     lPrPageOpen                    = $00040000;
  66.     lPrPageClose                = $00020000;
  67.     lPrDocClose                    = $00050000;
  68.     iFMgrCtl                    = 8;                            { The FMgr's Tail-hook Proc's ctl number }
  69.     iMscCtl                        = 9;                            { The FMgr's Tail-hook Proc's ctl number }
  70.     iPvtCtl                        = 10;                            { The FMgr's Tail-hook Proc's ctl number }
  71.  
  72. {     Error Codes moved to Errors.(hap)  }
  73.     pPrGlobals                    = $00000944;                    { The PrVars lo mem area: }
  74.     bDraftLoop                    = 0;
  75.     bSpoolLoop                    = 1;
  76.     bUser1Loop                    = 2;
  77.     bUser2Loop                    = 3;
  78.     fNewRunBit                    = 2;
  79.     fHiResOK                    = 3;
  80.     fWeOpenedRF                    = 4;                            { Driver constants  }
  81.     iPrBitsCtl                    = 4;
  82.     lScreenBits                    = 0;
  83.     lPaintBits                    = 1;
  84.     lHiScreenBits                = $00000002;                    { The Bitmap Print Proc's Screen Bitmap param }
  85.     lHiPaintBits                = $00000003;                    { The Bitmap Print Proc's Paint [sq pix] param }
  86.     iPrIOCtl                    = 5;
  87.     iPrEvtCtl                    = 6;                            { The PrEvent Proc's ctl number }
  88.     lPrEvtAll                    = $0002FFFD;                    { The PrEvent Proc's CParam for the entire screen }
  89.     lPrEvtTop                    = $0001FFFD;                    { The PrEvent Proc's CParam for the top folder }
  90.     iPrDrvrRef                    = -3;
  91.  
  92.     getRslDataOp                = 4;
  93.     setRslOp                    = 5;
  94.     draftBitsOp                    = 6;
  95.     noDraftBitsOp                = 7;
  96.     getRotnOp                    = 8;
  97.     NoSuchRsl                    = 1;
  98.     OpNotImpl                    = 2;                            { the driver doesn't support this opcode }
  99.     RgType1                        = 1;
  100.  
  101.     feedCut                        = 0;
  102.     feedFanfold                    = 1;
  103.     feedMechCut                    = 2;
  104.     feedOther                    = 3;
  105.  
  106.  
  107. TYPE
  108.     TFeed                                = SInt8;
  109.  
  110. CONST
  111.     scanTB                        = 0;
  112.     scanBT                        = 1;
  113.     scanLR                        = 2;
  114.     scanRL                        = 3;
  115.  
  116.  
  117. TYPE
  118.     TScan                                = SInt8;
  119. {  A Rect Ptr  }
  120.     TPRect                                = ^Rect;
  121.     PrIdleProcPtr = ProcPtr;  { PROCEDURE PrIdle; }
  122.  
  123.     PrIdleUPP = UniversalProcPtr;
  124.  
  125. CONST
  126.     uppPrIdleProcInfo = $00000000;
  127.  
  128. FUNCTION NewPrIdleProc(userRoutine: PrIdleProcPtr): PrIdleUPP;
  129.     {$IFC NOT GENERATINGCFM }
  130.     INLINE $2E9F;
  131.     {$ENDC}
  132.  
  133. PROCEDURE CallPrIdleProc(userRoutine: PrIdleUPP);
  134.     {$IFC NOT GENERATINGCFM}
  135.     INLINE $205F, $4E90;
  136.     {$ENDC}
  137. {$IFC FOR_OPAQUE_SYSTEM_DATA_STRUCTURES }
  138.  
  139. TYPE
  140.     PItemProcPtr = ProcPtr;  { PROCEDURE PItem(theDialog: DialogRef; item: INTEGER); }
  141.  
  142.     PItemUPP = UniversalProcPtr;
  143.  
  144. CONST
  145.     uppPItemProcInfo = $000002C0;
  146.  
  147. FUNCTION NewPItemProc(userRoutine: PItemProcPtr): PItemUPP;
  148.     {$IFC NOT GENERATINGCFM }
  149.     INLINE $2E9F;
  150.     {$ENDC}
  151.  
  152. PROCEDURE CallPItemProc(theDialog: DialogRef; item: INTEGER; userRoutine: PItemUPP);
  153.     {$IFC NOT GENERATINGCFM}
  154.     INLINE $205F, $4E90;
  155.     {$ENDC}
  156.  
  157. TYPE
  158.     TPPrPort = ^LONGINT;
  159.     TPPrPortRef                            = TPPrPort;
  160. {$ELSEC}
  161.  
  162. TYPE
  163.     PItemProcPtr = ProcPtr;  { PROCEDURE PItem(theDialog: DialogPtr; item: INTEGER); }
  164.  
  165.     PItemUPP = UniversalProcPtr;
  166.  
  167. CONST
  168.     uppPItemProcInfo = $000002C0;
  169.  
  170. FUNCTION NewPItemProc(userRoutine: PItemProcPtr): PItemUPP;
  171.     {$IFC NOT GENERATINGCFM }
  172.     INLINE $2E9F;
  173.     {$ENDC}
  174.  
  175. PROCEDURE CallPItemProc(theDialog: DialogPtr; item: INTEGER; userRoutine: PItemUPP);
  176.     {$IFC NOT GENERATINGCFM}
  177.     INLINE $205F, $4E90;
  178.     {$ENDC}
  179.  
  180. TYPE
  181.     TPrPortPtr = ^TPrPort;
  182.     TPrPort = RECORD
  183.         gPort:                    GrafPort;                                { The Printer's graf port. }
  184.         gProcs:                    QDProcs;                                { ..and its procs }
  185.         lGParam1:                LONGINT;                                { 16 bytes for private parameter storage. }
  186.         lGParam2:                LONGINT;
  187.         lGParam3:                LONGINT;
  188.         lGParam4:                LONGINT;
  189.         fOurPtr:                BOOLEAN;                                { Whether the PrPort allocation was done by us. }
  190.         fOurBits:                BOOLEAN;                                { Whether the BitMap allocation was done by us. }
  191.     END;
  192.  
  193.     TPPrPort                            = ^TPrPort;
  194.     TPPrPortRef                            = ^TPrPort;
  195. {$ENDC}
  196. {
  197.  Printing Graf Port. All printer imaging, whether spooling, banding, etc, happens "thru" a GrafPort.
  198.   This is the "PrPeek" record. 
  199. }
  200.     TPrInfoPtr = ^TPrInfo;
  201.     TPrInfo = RECORD
  202.         iDev:                    INTEGER;                                { Font mgr/QuickDraw device code }
  203.         iVRes:                    INTEGER;                                { Resolution of device, in device coordinates }
  204.         iHRes:                    INTEGER;                                { ..note: V before H => compatable with Point. }
  205.         rPage:                    Rect;                                    { The page (printable) rectangle in device coordinates. }
  206.     END;
  207.  
  208.     TPPrInfo                            = ^TPrInfo;
  209. {  Print Info Record: The parameters needed for page composition.  }
  210.     TPrStlPtr = ^TPrStl;
  211.     TPrStl = RECORD
  212.         wDev:                    INTEGER;
  213.         iPageV:                    INTEGER;
  214.         iPageH:                    INTEGER;
  215.         bPort:                    SInt8;
  216.         feed:                    TFeed;
  217.     END;
  218.  
  219.     TPPrStl                                = ^TPrStl;
  220.     TPrXInfoPtr = ^TPrXInfo;
  221.     TPrXInfo = RECORD
  222.         iRowBytes:                INTEGER;
  223.         iBandV:                    INTEGER;
  224.         iBandH:                    INTEGER;
  225.         iDevBytes:                INTEGER;
  226.         iBands:                    INTEGER;
  227.         bPatScale:                SInt8;
  228.         bUlThick:                SInt8;
  229.         bUlOffset:                SInt8;
  230.         bUlShadow:                SInt8;
  231.         scan:                    TScan;
  232.         bXInfoX:                SInt8;
  233.     END;
  234.  
  235.     TPPrXInfo                            = ^TPrXInfo;
  236.     TPrJobPtr = ^TPrJob;
  237.     TPrJob = RECORD
  238.         iFstPage:                INTEGER;                                { Page Range. }
  239.         iLstPage:                INTEGER;
  240.         iCopies:                INTEGER;                                { No. copies. }
  241.         bJDocLoop:                SInt8;                                    { The Doc style: Draft, Spool, .., and .. }
  242.         fFromUsr:                BOOLEAN;                                { Printing from an User's App (not PrApp) flag }
  243.         pIdleProc:                PrIdleUPP;                                { The Proc called while waiting on IO etc. }
  244.         pFileName:                StringPtr;                                { Spool File Name: NIL for default. }
  245.         iFileVol:                INTEGER;                                { Spool File vol, set to 0 initially }
  246.         bFileVers:                SInt8;                                    { Spool File version, set to 0 initially }
  247.         bJobX:                    SInt8;                                    { An eXtra byte. }
  248.     END;
  249.  
  250.     TPPrJob                                = ^TPrJob;
  251. {  Print Job: Print "form" for a single print request.  }
  252.     TPrFlag1Ptr = ^TPrFlag1;
  253.     TPrFlag1 = PACKED RECORD
  254.         f15:                    BOOLEAN;
  255.         f14:                    BOOLEAN;
  256.         f13:                    BOOLEAN;
  257.         f12:                    BOOLEAN;
  258.         f11:                    BOOLEAN;
  259.         f10:                    BOOLEAN;
  260.         f9:                        BOOLEAN;
  261.         f8:                        BOOLEAN;
  262.         f7:                        BOOLEAN;
  263.         f6:                        BOOLEAN;
  264.         f5:                        BOOLEAN;
  265.         f4:                        BOOLEAN;
  266.         f3:                        BOOLEAN;
  267.         f2:                        BOOLEAN;
  268.         fLstPgFst:                BOOLEAN;
  269.         fUserScale:                BOOLEAN;
  270.     END;
  271.  
  272.     TPrintPtr = ^TPrint;
  273.     TPrint = RECORD
  274.         iPrVersion:                INTEGER;                                { (2) Printing software version }
  275.         prInfo:                    TPrInfo;                                { (14) the PrInfo data associated with the current style. }
  276.         rPaper:                    Rect;                                    { (8) The paper rectangle [offset from rPage] }
  277.         prStl:                    TPrStl;                                    { (8)  This print request's style. }
  278.         prInfoPT:                TPrInfo;                                { (14)  Print Time Imaging metrics }
  279.         prXInfo:                TPrXInfo;                                { (16)  Print-time (expanded) Print info record. }
  280.         prJob:                    TPrJob;                                    { (20) The Print Job request (82)  Total of the above; 120-82 = 38 bytes needed to fill 120 }
  281.         CASE INTEGER OF
  282.         0: (
  283.             printX:                ARRAY [1..19] OF INTEGER;
  284.             );
  285.         1: (
  286.             prFlag1:            TPrFlag1;
  287.             iZoomMin:            INTEGER;
  288.             iZoomMax:            INTEGER;
  289.             hDocName:            StringHandle;
  290.            );
  291.     END;
  292.  
  293.     TPPrint                                = ^TPrint;
  294.     THPrint                                = ^TPPrint;
  295. {$IFC FOR_OPAQUE_SYSTEM_DATA_STRUCTURES }
  296. {
  297.  typedef struct OpaqueTPrStatusRef *TPPrStatus;
  298.  typedef struct OpaqueTPrStatusRef *TPPrStatusRef;
  299. }
  300.     TPPrStatus = ^LONGINT;
  301.     TPPrStatusRef                        = TPPrStatus;
  302. {$ELSEC}
  303.     TPrStatusPtr = ^TPrStatus;
  304.     TPrStatus = RECORD
  305.         iTotPages:                INTEGER;                                { Total pages in Print File. }
  306.         iCurPage:                INTEGER;                                { Current page number }
  307.         iTotCopies:                INTEGER;                                { Total copies requested }
  308.         iCurCopy:                INTEGER;                                { Current copy number }
  309.         iTotBands:                INTEGER;                                { Total bands per page. }
  310.         iCurBand:                INTEGER;                                { Current band number }
  311.         fPgDirty:                BOOLEAN;                                { True if current page has been written to. }
  312.         fImaging:                BOOLEAN;                                { Set while in band's DrawPic call. }
  313.         hPrint:                    THPrint;                                { Handle to the active Printer record }
  314.         pPrPort:                TPPrPortRef;                            { Ptr to the active PrPort }
  315.         hPic:                    PicHandle;                                { Handle to the active Picture }
  316.     END;
  317.  
  318.     TPPrStatus                            = ^TPrStatus;
  319.     TPPrStatusRef                        = ^TPrStatus;
  320. {$ENDC}
  321. {  Print Status: Print information during printing.  }
  322.     TPfPgDirPtr = ^TPfPgDir;
  323.     TPfPgDir = RECORD
  324.         iPages:                    INTEGER;
  325.         iPgPos:                    ARRAY [0..128] OF LONGINT;                { ARRAY [0..iPfMaxPgs] OF LONGINT }
  326.     END;
  327.  
  328.     TPPfPgDir                            = ^TPfPgDir;
  329.     THPfPgDir                            = ^TPPfPgDir;
  330. {  PicFile = a TPfHeader followed by n QuickDraw Pics (whose PicSize is invalid!)  }
  331. {
  332.  This is the Printing Dialog Record. Only used by folks appending their own
  333.    DITLs to the print dialogs.    Print Dialog: The Dialog Stream object. 
  334. }
  335. {$IFC FOR_OPAQUE_SYSTEM_DATA_STRUCTURES }
  336. {
  337.  typedef struct OpaqueTPrDlgRef *TPPrDlg;
  338.  typedef struct OpaqueTPrDlgRef *TPPrDlgRef;
  339. }
  340.     TPPrDlg = ^LONGINT;
  341.     TPPrDlgRef                            = TPPrDlg;
  342. {$ELSEC}
  343.     TPrDlgPtr = ^TPrDlg;
  344.     TPrDlg = RECORD
  345.         Dlg:                    DialogRecord;                            { The Dialog window }
  346.         pFltrProc:                ModalFilterUPP;                            { The Filter Proc. }
  347.         pItemProc:                PItemUPP;                                { The Item evaluating proc. }
  348.         hPrintUsr:                THPrint;                                { The user's print record. }
  349.         fDoIt:                    BOOLEAN;
  350.         fDone:                    BOOLEAN;
  351.         lUser1:                    LONGINT;                                { Four longs for apps to hang global data. }
  352.         lUser2:                    LONGINT;                                { Plus more stuff needed by the particular }
  353.         lUser3:                    LONGINT;                                { printing dialog. }
  354.         lUser4:                    LONGINT;
  355.     END;
  356.  
  357.     TPPrDlg                                = ^TPrDlg;
  358.     TPPrDlgRef                            = ^TPrDlg;
  359. {$ENDC}
  360.     PDlgInitProcPtr = ProcPtr;  { FUNCTION PDlgInit(hPrint: THPrint): TPPrDlgRef; }
  361.  
  362.     PDlgInitUPP = UniversalProcPtr;
  363.  
  364. CONST
  365.     uppPDlgInitProcInfo = $000000F0;
  366.  
  367. FUNCTION NewPDlgInitProc(userRoutine: PDlgInitProcPtr): PDlgInitUPP;
  368.     {$IFC NOT GENERATINGCFM }
  369.     INLINE $2E9F;
  370.     {$ENDC}
  371.  
  372. FUNCTION CallPDlgInitProc(hPrint: THPrint; userRoutine: PDlgInitUPP): TPPrDlgRef;
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $205F, $4E90;
  375.     {$ENDC}
  376.  
  377. TYPE
  378.     TGnlDataPtr = ^TGnlData;
  379.     TGnlData = RECORD
  380.         iOpCode:                INTEGER;
  381.         iError:                    INTEGER;
  382.         lReserved:                LONGINT;                                { more fields here depending on call }
  383.     END;
  384.  
  385.     TRslRgPtr = ^TRslRg;
  386.     TRslRg = RECORD
  387.         iMin:                    INTEGER;
  388.         iMax:                    INTEGER;
  389.     END;
  390.  
  391.     TRslRecPtr = ^TRslRec;
  392.     TRslRec = RECORD
  393.         iXRsl:                    INTEGER;
  394.         iYRsl:                    INTEGER;
  395.     END;
  396.  
  397.     TGetRslBlkPtr = ^TGetRslBlk;
  398.     TGetRslBlk = RECORD
  399.         iOpCode:                INTEGER;
  400.         iError:                    INTEGER;
  401.         lReserved:                LONGINT;
  402.         iRgType:                INTEGER;
  403.         xRslRg:                    TRslRg;
  404.         yRslRg:                    TRslRg;
  405.         iRslRecCnt:                INTEGER;
  406.         rgRslRec:                ARRAY [1..27] OF TRslRec;
  407.     END;
  408.  
  409.     TSetRslBlkPtr = ^TSetRslBlk;
  410.     TSetRslBlk = RECORD
  411.         iOpCode:                INTEGER;
  412.         iError:                    INTEGER;
  413.         lReserved:                LONGINT;
  414.         hPrint:                    THPrint;
  415.         iXRsl:                    INTEGER;
  416.         iYRsl:                    INTEGER;
  417.     END;
  418.  
  419.     TDftBitsBlkPtr = ^TDftBitsBlk;
  420.     TDftBitsBlk = RECORD
  421.         iOpCode:                INTEGER;
  422.         iError:                    INTEGER;
  423.         lReserved:                LONGINT;
  424.         hPrint:                    THPrint;
  425.     END;
  426.  
  427.     TGetRotnBlkPtr = ^TGetRotnBlk;
  428.     TGetRotnBlk = RECORD
  429.         iOpCode:                INTEGER;
  430.         iError:                    INTEGER;
  431.         lReserved:                LONGINT;
  432.         hPrint:                    THPrint;
  433.         fLandscape:                BOOLEAN;
  434.         bXtra:                    SInt8;
  435.     END;
  436.  
  437. PROCEDURE PrPurge;
  438.     {$IFC NOT GENERATINGCFM}
  439.     INLINE $2F3C, $A800, $0000, $A8FD;
  440.     {$ENDC}
  441. PROCEDURE PrNoPurge;
  442.     {$IFC NOT GENERATINGCFM}
  443.     INLINE $2F3C, $B000, $0000, $A8FD;
  444.     {$ENDC}
  445. PROCEDURE PrOpen;
  446.     {$IFC NOT GENERATINGCFM}
  447.     INLINE $2F3C, $C800, $0000, $A8FD;
  448.     {$ENDC}
  449. PROCEDURE PrClose;
  450.     {$IFC NOT GENERATINGCFM}
  451.     INLINE $2F3C, $D000, $0000, $A8FD;
  452.     {$ENDC}
  453. PROCEDURE PrintDefault(hPrint: THPrint);
  454.     {$IFC NOT GENERATINGCFM}
  455.     INLINE $2F3C, $2004, $0480, $A8FD;
  456.     {$ENDC}
  457. FUNCTION PrValidate(hPrint: THPrint): BOOLEAN;
  458.     {$IFC NOT GENERATINGCFM}
  459.     INLINE $2F3C, $5204, $0498, $A8FD;
  460.     {$ENDC}
  461. FUNCTION PrStlDialog(hPrint: THPrint): BOOLEAN;
  462.     {$IFC NOT GENERATINGCFM}
  463.     INLINE $2F3C, $2A04, $0484, $A8FD;
  464.     {$ENDC}
  465. FUNCTION PrJobDialog(hPrint: THPrint): BOOLEAN;
  466.     {$IFC NOT GENERATINGCFM}
  467.     INLINE $2F3C, $3204, $0488, $A8FD;
  468.     {$ENDC}
  469. FUNCTION PrStlInit(hPrint: THPrint): TPPrDlgRef;
  470.     {$IFC NOT GENERATINGCFM}
  471.     INLINE $2F3C, $3C04, $040C, $A8FD;
  472.     {$ENDC}
  473. FUNCTION PrJobInit(hPrint: THPrint): TPPrDlgRef;
  474.     {$IFC NOT GENERATINGCFM}
  475.     INLINE $2F3C, $4404, $0410, $A8FD;
  476.     {$ENDC}
  477. PROCEDURE PrJobMerge(hPrintSrc: THPrint; hPrintDst: THPrint);
  478.     {$IFC NOT GENERATINGCFM}
  479.     INLINE $2F3C, $5804, $089C, $A8FD;
  480.     {$ENDC}
  481. FUNCTION PrDlgMain(hPrint: THPrint; pDlgInit: PDlgInitUPP): BOOLEAN;
  482.     {$IFC NOT GENERATINGCFM}
  483.     INLINE $2F3C, $4A04, $0894, $A8FD;
  484.     {$ENDC}
  485. FUNCTION PrOpenDoc(hPrint: THPrint; pPrPort: TPPrPortRef; pIOBuf: Ptr): TPPrPortRef;
  486.     {$IFC NOT GENERATINGCFM}
  487.     INLINE $2F3C, $0400, $0C00, $A8FD;
  488.     {$ENDC}
  489. PROCEDURE PrCloseDoc(pPrPort: TPPrPortRef);
  490.     {$IFC NOT GENERATINGCFM}
  491.     INLINE $2F3C, $0800, $0484, $A8FD;
  492.     {$ENDC}
  493. PROCEDURE PrOpenPage(pPrPort: TPPrPortRef; pPageFrame: TPRect);
  494.     {$IFC NOT GENERATINGCFM}
  495.     INLINE $2F3C, $1000, $0808, $A8FD;
  496.     {$ENDC}
  497. PROCEDURE PrClosePage(pPrPort: TPPrPortRef);
  498.     {$IFC NOT GENERATINGCFM}
  499.     INLINE $2F3C, $1800, $040C, $A8FD;
  500.     {$ENDC}
  501. PROCEDURE PrPicFile(hPrint: THPrint; pPrPort: TPPrPortRef; pIOBuf: Ptr; pDevBuf: Ptr; prStatus: TPPrStatusRef);
  502.     {$IFC NOT GENERATINGCFM}
  503.     INLINE $2F3C, $6005, $1480, $A8FD;
  504.     {$ENDC}
  505. FUNCTION PrError: INTEGER;
  506.     {$IFC NOT GENERATINGCFM}
  507.     INLINE $2F3C, $BA00, $0000, $A8FD;
  508.     {$ENDC}
  509. PROCEDURE PrSetError(iErr: INTEGER);
  510.     {$IFC NOT GENERATINGCFM}
  511.     INLINE $2F3C, $C000, $0200, $A8FD;
  512.     {$ENDC}
  513. PROCEDURE PrGeneral(pData: Ptr);
  514.     {$IFC NOT GENERATINGCFM}
  515.     INLINE $2F3C, $7007, $0480, $A8FD;
  516.     {$ENDC}
  517. PROCEDURE PrDrvrOpen;
  518.     {$IFC NOT GENERATINGCFM}
  519.     INLINE $2F3C, $8000, $0000, $A8FD;
  520.     {$ENDC}
  521. PROCEDURE PrDrvrClose;
  522.     {$IFC NOT GENERATINGCFM}
  523.     INLINE $2F3C, $8800, $0000, $A8FD;
  524.     {$ENDC}
  525. PROCEDURE PrCtlCall(iWhichCtl: INTEGER; lParam1: LONGINT; lParam2: LONGINT; lParam3: LONGINT);
  526.     {$IFC NOT GENERATINGCFM}
  527.     INLINE $2F3C, $A000, $0E00, $A8FD;
  528.     {$ENDC}
  529. FUNCTION PrDrvrDCE: Handle;
  530.     {$IFC NOT GENERATINGCFM}
  531.     INLINE $2F3C, $9400, $0000, $A8FD;
  532.     {$ENDC}
  533. FUNCTION PrDrvrVers: INTEGER;
  534.     {$IFC NOT GENERATINGCFM}
  535.     INLINE $2F3C, $9A00, $0000, $A8FD;
  536.     {$ENDC}
  537. FUNCTION PrLoadDriver: INTEGER;
  538.     {$IFC NOT GENERATINGCFM}
  539.     INLINE $2F3C, $D800, $0000, $A8FD;
  540.     {$ENDC}
  541. {$ENDC}
  542. {$ALIGN RESET}
  543. {$POP}
  544.  
  545. {$SETC UsingIncludes := PrintingIncludes}
  546.  
  547. {$ENDC} {__PRINTING__}
  548.  
  549. {$IFC NOT UsingIncludes}
  550.  END.
  551. {$ENDC}
  552.